{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CategoricalDQN_CartPole-v1\n",
    "\n",
    "[CategoricalDQN](https://arxiv.org/pdf/1707.06887), 又称C51算法, 由 Bellemare 等人在 2017 年提出，是值分布强化学习（Distributional Reinforcement Learning）的经典方法之一。 相比于经典DQN算法，从理论上其优点有：\n",
    "* 学到的信息更丰富，不仅仅是期望，还有不确定性\n",
    "* 通常具有更稳定的训练效果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义参数\n",
    "\n",
    "为方便实验调试，把所有参数都放在一起"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.algo_name = 'C51' # 算法名称\n",
    "        self.env_id = 'CartPole-v1' # 环境id\n",
    "        self.mode = 'train'\n",
    "        self.seed = 1 # 随机种子，便于复现，0表示不设置\n",
    "        self.max_epsiode = 200 # 训练的回合数\n",
    "        self.max_step = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        #region 在线测试相关参数\n",
    "        self.online_eval_episode = 10 # 测试的回合数\n",
    "        self.online_eval_freq = 2000 # 在线测试的频率, 模型每更新N次就测试一次\n",
    "        #endregion\n",
    "        self.gamma = 0.99 # 折扣因子\n",
    "        self.epsilon_start = 0.95 # e-greedy策略中初始epsilon\n",
    "        self.epsilon_end = 0.01 # e-greedy策略中的终止epsilon\n",
    "        self.epsilon_decay = 0.0004 # e-greedy策略中epsilon的衰减率\n",
    "        self.buffer_size = 8000 # 经验回放池的容量\n",
    "        self.hidden_dim = 256 # 神经网络的隐藏层维度\n",
    "        self.batch_size = 256 # 批次大小\n",
    "        self.target_update = 100 # 目标网络的更新频率\n",
    "        self.update_every = 50 # 每采样50步更新\n",
    "        self.lr = 0.0001 # 学习率\n",
    "        self.tau = 0.005 # 软更新参数\n",
    "        # 被称为C51的原因就是原子个数为51\n",
    "        self.n_atoms = 51 # 原子个数\n",
    "        self.v_min = -100 # 原子的最小值\n",
    "        self.v_max = 100 # 原子的最大值\n",
    "        self.device = 'cpu' if not torch.cuda.is_available() else 'cuda' # 使用cpu还是gpu\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "定义一个三层的全连接网络（FCN），也叫多层感知机（MLP）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, cfg: Config, state_dim, action_dim, hidden_dim=256):\n",
    "        \"\"\" 初始化q网络, 为全连接网络\n",
    "        \"\"\"\n",
    "        super(Model, self).__init__()\n",
    "        self.n_atoms = cfg.n_atoms\n",
    "        self.action_dim = action_dim\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(state_dim, hidden_dim), # 输入层\n",
    "            nn.ReLU(), # 激活函数\n",
    "            nn.Linear(hidden_dim, hidden_dim), # 隐藏层\n",
    "            nn.ReLU(), # 激活函数\n",
    "            nn.Linear(hidden_dim, action_dim * self.n_atoms) # 输出层\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # 各层对应的激活函数\n",
    "        # batch_size = x.size(0)\n",
    "        logits = self.layers(x)\n",
    "        dist = torch.softmax(logits.view(-1, self.action_dim, self.n_atoms), dim=2) # (B, a_dim, n_atoms)\n",
    "        return dist"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "经验回放主要有两个功能，一是存储样本(push)，二是随时采样样本(sample)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, cfg: Config) -> None:\n",
    "        self.capacity = cfg.buffer_size\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self, transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "        \n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "\n",
    "智能体主要负责与环境交互并更新策略(模型参数)，因此首先需要定义sample_action和predict_action两个函数，前者用于训练时的采样动作，一般会采取$\\varepsilon-\\text{greedy}$策略来提高探索能力，后者一般用于测试算法时的预测动作。其次需要定义update函数，这个函数主要用来从经验回放中采样样本，然后更新模型参数。\n",
    "\n",
    "注意：\n",
    "* 每个张量的维度要对应上，否则可能会报错或者不收敛"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "import math\n",
    "import numpy as np\n",
    "\n",
    "class ExplorationMgr:\n",
    "    ''' 探索管理器\n",
    "    '''\n",
    "    def __init__(self, cfg: Config):\n",
    "\n",
    "        self.epsilon_start = cfg.epsilon_start\n",
    "        self.epsilon_end = cfg.epsilon_end\n",
    "        self.epsilon_decay = cfg.epsilon_decay\n",
    "        self.epsilon = cfg.epsilon_start\n",
    "        self.update_cnt = 0\n",
    "\n",
    "    def update_epsilon(self):\n",
    "        ''' 更新并返回探索概率\n",
    "        '''\n",
    "        self.update_cnt += 1\n",
    "        self.epsilon = self.epsilon_end + (self.epsilon_start - self.epsilon_end) * \\\n",
    "            math.exp(-1. * self.update_cnt * self.epsilon_decay) \n",
    "        return self.epsilon\n",
    "\n",
    "class Policy:\n",
    "    def __init__(self, cfg: Config, state_dim:int, action_dim:int):\n",
    "        self.tau = cfg.tau # 软更新的参数\n",
    "        self.action_dim = action_dim # 动作空间的维度\n",
    "        self.gamma = cfg.gamma # 奖励的折扣因子\n",
    "        self.n_atoms = cfg.n_atoms # 离散化的原子数\n",
    "        self.v_min = cfg.v_min # 原子的最小值\n",
    "        self.v_max = cfg.v_max # 原子的最大值\n",
    "        self.batch_size = cfg.batch_size # 批量大小\n",
    "        self.device = torch.device(cfg.device) # CPU或GPU \n",
    "        # e-greedy策略相关参数\n",
    "        self.support = torch.linspace(self.v_min, self.v_max, steps = self.n_atoms, device=self.device)\n",
    "        self.proj_dist = torch.zeros((self.batch_size, self.n_atoms), device=self.device) # [B, n_atoms]\n",
    "        self.offset = torch.linspace(0, (self.batch_size - 1) * self.n_atoms, self.batch_size,device=self.device).unsqueeze(-1).long() # [B, 1]\n",
    "        self.delta_z = float(self.v_max - self.v_min) / (self.n_atoms - 1)\n",
    "        self.memory = ReplayBuffer(cfg)\n",
    "        self.exploration_mgr = ExplorationMgr(cfg) # 探索管理器\n",
    "        # 当前网络和目标网络\n",
    "        self.model = Model(cfg, state_dim, self.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        # print(self.model(torch.randn(1, cfg.state_dim)))\n",
    "        self.target_model = Model(cfg, state_dim, self.action_dim, hidden_dim = cfg.hidden_dim).to(self.device)\n",
    "        # 复制参数到目标网络\n",
    "        self.target_model.load_state_dict(self.model.state_dict())\n",
    "        # for target_param, param in zip(self.target_model.parameters(),self.model.parameters()): \n",
    "        #     target_param.data.copy_(param.data)\n",
    "        self.optimizer = optim.Adam(self.model.parameters(), lr=cfg.lr) # 优化器\n",
    "        self.update_cnt = 0 # 用于延迟更新目标网络的计数\n",
    "        \n",
    "    def sample_action(self, state):\n",
    "        ''' 采样动作\n",
    "        '''\n",
    "        if random.random() > self.exploration_mgr.update_epsilon(): # epsilon-greedy策略\n",
    "            action = self.predict_action(state)\n",
    "        else:\n",
    "            action = random.randrange(self.action_dim)\n",
    "        return action\n",
    "    \n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def predict_action(self, state):\n",
    "        ''' 预测动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0) # [1, state_dim]\n",
    "        dist = self.model(state)\n",
    "        q_values = (dist * self.support).sum(2)\n",
    "        action = torch.argmax(q_values).detach().cpu().numpy().item()\n",
    "        return action\n",
    "    \n",
    "    def get_policy_params(self):\n",
    "        ''' 获取当前策略的参数\n",
    "        '''\n",
    "        return self.model.state_dict()\n",
    "    \n",
    "    def set_policy_params(self, policy_params):\n",
    "        ''' 设置当前策略的参数\n",
    "        '''\n",
    "        self.model.load_state_dict(policy_params)\n",
    "        self.target_model.load_state_dict(policy_params)\n",
    "    \n",
    "    @torch.no_grad() # 不计算梯度，该装饰器效果等同于with torch.no_grad()：\n",
    "    def projection_distribution(self, next_states, rewards, dones):\n",
    "        ''' 用于计算下一时刻的分布\n",
    "        '''\n",
    "        next_dist = self.target_model(next_states) # [batch_size, action_dim, n_atoms]\n",
    "        next_q_values = (next_dist * self.support).sum(2) # [batch_size, action_dim]\n",
    "        next_actions = torch.argmax(next_q_values, dim=1) # [batch_size]\n",
    "        next_dist = next_dist[torch.arange(self.batch_size), next_actions.flatten()] # [batch_size, n_atoms]\n",
    "        Tz = rewards + (1-dones) * self.gamma * self.support\n",
    "        Tz = Tz.clamp(min = self.v_min, max = self.v_max)\n",
    "        b = (Tz - self.v_min) / self.delta_z\n",
    "        l = b.floor().long()\n",
    "        u = b.ceil().long()\n",
    "        delta_m_l = (u + (l == u) - b) * next_dist  # (batch_size, n_atoms)\n",
    "        delta_m_u = (b - l) * next_dist # (batch_size, n_atoms)\n",
    "        self.proj_dist *= 0\n",
    "        self.proj_dist.view(-1).index_add_(0, (l + self.offset).view(-1), delta_m_l.view(-1))\n",
    "        self.proj_dist.view(-1).index_add_(0, (u + self.offset).view(-1), delta_m_u.view(-1))\n",
    "\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 从经验回放中随机采样一个批量的样本\n",
    "        states, actions, rewards, next_states, dones = self.memory.sample(\n",
    "            self.batch_size)\n",
    "        # 将数据转换为tensor\n",
    "        states = torch.tensor(np.array(states), device = self.device, dtype=torch.float) # [B, state_dim]\n",
    "        actions = torch.tensor(actions, device=self.device,  dtype = torch.int64).unsqueeze(1)  #  [B, 1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1)   # [B, 1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [batchB_size, state_dim]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1)  # [batch_size,1]\n",
    "        # 计算下一时刻的分布\n",
    "        self.projection_distribution(next_states, rewards, dones)\n",
    "        # 计算当前状态的分布\n",
    "        dist = self.model(states) # [batch_size, action_dim, n_atoms]\n",
    "        dist = dist[torch.arange(self.batch_size), actions.flatten()]\n",
    "        # dist = dist.gather(1, actions.unsqueeze(1).expand(self.batch_size, 1, self.n_atoms)).squeeze(1) # [batch_size, n_atoms]\n",
    "        # dist = dist[torch.arange(self.cfg.batch_size), actions.squeeze(1).cpu().numpy()] # [batch_size, n_atoms]\n",
    "        # action_ = actions.unsqueeze(1).expand(self.batch_size, 1, self.n_atoms)\n",
    "        # dist = dist.gather(1, action_).squeeze(1) # [batch_size, n_atoms]\n",
    "        # dist.data.clamp_(0.01, 0.99) # 为了数值稳定，将概率值限制在[0.01, 0.99]之间\n",
    "        # print(self.proj_dist.shape, dist.shape)\n",
    "        loss = (-(self.proj_dist * dist.clamp(min=1e-5, max=1 - 1e-5).log()).sum(-1)).mean()\n",
    "        # print(proj_dist.grad_fn, dist.grad_fn)\n",
    "        # print(loss)\n",
    "        self.optimizer.zero_grad()  \n",
    "        loss.backward()\n",
    "        # clip防止梯度爆炸\n",
    "        # for param in self.model.parameters():  \n",
    "        #     param.grad.data.clamp_(-1, 1)\n",
    "        # torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)\n",
    "        self.optimizer.step() \n",
    "        self.update_cnt += 1\n",
    "        # 每隔一定步数更新目标网络的参数\n",
    "        # 软更新\n",
    "        for param, target_param in zip(self.model.parameters(), self.target_model.parameters()):\n",
    "            target_param.data.copy_(self.tau * param.data + (1 - self.tau) * target_param.data)\n",
    "\n",
    "        # if self.update_cnt % self.target_hard_update_freq == 0:\n",
    "        #     self.target_model.load_state_dict(self.model.state_dict())\n",
    "        return loss.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义可视化函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_curve(cfg: Config, frames: list, rewards : list, label:str = \"rewards\", title:str = None):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    if title is None:\n",
    "        title = f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\"\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(title)\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label=f\"{label}\")\n",
    "    plt.plot(frames, smooth(rewards), label=f\"{label}_smoothed\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg: Config):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    allow_types = ['int', 'float', 'str', 'bool', 'list', 'dict']\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        if v.__class__.__name__ not in allow_types:\n",
    "            continue\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "\n",
    "class EnvMgr:\n",
    "    def __init__(self, cfg: Config):\n",
    "        self.env = gym.make(cfg.env_id) # 创建环境\n",
    "        self.eval_env = gym.make(cfg.env_id)\n",
    "        print(f\"env id: {cfg.env_id}, state_dim: {self.state_dim}, action_dim: {self.action_dim}\")\n",
    "    @property\n",
    "    def action_dim(self):\n",
    "        return self.env.action_space.n # 动作空间的维度\n",
    "    @property\n",
    "    def state_dim(self):\n",
    "        return self.env.observation_space.shape[0]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义训练和测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import gymnasium as gym\n",
    "\n",
    "\n",
    "def eval_policy(cfg: Config, policy: Policy, env):\n",
    "    ''' 测试\n",
    "    '''\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg.online_eval_episode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            action = policy.predict_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "    \n",
    "    return np.mean(rewards)\n",
    "\n",
    "def train(cfg: Config, policy: Policy, env_mgr: EnvMgr):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env = env_mgr.env\n",
    "    eval_env = env_mgr.eval_env\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    eval_rewards = []  # 记录所有回合的奖励\n",
    "    losses = []  # 记录所有回合的损失\n",
    "    best_policy_params = None  # 最佳策略\n",
    "    best_ep_reward = float('-inf') # 最佳回合的奖励\n",
    "\n",
    "    tot_step = 0\n",
    "    for i_ep in range(cfg.max_epsiode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            ep_step += 1\n",
    "            tot_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , info = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, terminated or truncated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            # 更新智能体，这里也可以改成每采样50步再更新50次\n",
    "            if tot_step%cfg.update_every == 0:\n",
    "                for _ in range(cfg.update_every):\n",
    "                    loss = policy.update()  \n",
    "                    if loss is not None:\n",
    "                        losses.append(loss)\n",
    "                if policy.update_cnt > 0 and policy.update_cnt % cfg.online_eval_freq == 0:\n",
    "                    eval_reward = eval_policy(cfg, policy, eval_env)\n",
    "                    eval_rewards.append(eval_reward)\n",
    "                    if eval_reward >= best_ep_reward:\n",
    "                        print(f\"找到新的最优策略，回合：{i_ep+1}，模型步数：{policy.update_cnt}，测试奖励：{eval_reward:.2f}\")\n",
    "                        best_ep_reward = eval_reward\n",
    "                        best_policy_params = policy.get_policy_params()\n",
    "            # policy.update() \n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.max_epsiode}，奖励：{ep_reward:.2f}，Epislon：{policy.exploration_mgr.epsilon:.3f}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'eval_rewards':eval_rewards, 'losses':losses,'best_policy_params':best_policy_params}\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env id: CartPole-v1, state_dim: 4, action_dim: 2\n",
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t        C51         \t   <class 'str'>    \n",
      "       env_id       \t    CartPole-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "    max_epsiode     \t        200         \t   <class 'int'>    \n",
      "      max_step      \t        200         \t   <class 'int'>    \n",
      "online_eval_episode \t         10         \t   <class 'int'>    \n",
      "  online_eval_freq  \t        2000        \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "   epsilon_start    \t        0.95        \t  <class 'float'>   \n",
      "    epsilon_end     \t        0.01        \t  <class 'float'>   \n",
      "   epsilon_decay    \t       0.0004       \t  <class 'float'>   \n",
      "    buffer_size     \t        8000        \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t        256         \t   <class 'int'>    \n",
      "   target_update    \t        100         \t   <class 'int'>    \n",
      "    update_every    \t         50         \t   <class 'int'>    \n",
      "         lr         \t       0.0001       \t  <class 'float'>   \n",
      "        tau         \t       0.005        \t  <class 'float'>   \n",
      "      n_atoms       \t         51         \t   <class 'int'>    \n",
      "       v_min        \t        -100        \t   <class 'int'>    \n",
      "       v_max        \t        100         \t   <class 'int'>    \n",
      "       device       \t        cuda        \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/200，奖励：18.00，Epislon：0.835\n",
      "回合：20/200，奖励：44.00，Epislon：0.754\n",
      "回合：30/200，奖励：48.00，Epislon：0.683\n",
      "回合：40/200，奖励：92.00，Epislon：0.616\n",
      "回合：50/200，奖励：31.00，Epislon：0.575\n",
      "回合：60/200，奖励：11.00，Epislon：0.532\n",
      "回合：70/200，奖励：27.00，Epislon：0.486\n",
      "回合：80/200，奖励：54.00，Epislon：0.432\n",
      "找到新的最优策略，回合：83，模型步数：2000，测试奖励：200.00\n",
      "回合：90/200，奖励：200.00，Epislon：0.257\n",
      "找到新的最优策略，回合：95，模型步数：4000，测试奖励：200.00\n",
      "回合：100/200，奖励：200.00，Epislon：0.121\n",
      "找到新的最优策略，回合：105，模型步数：6000，测试奖励：200.00\n",
      "回合：110/200，奖励：200.00，Epislon：0.060\n",
      "找到新的最优策略，回合：115，模型步数：8000，测试奖励：200.00\n",
      "回合：120/200，奖励：200.00，Epislon：0.033\n",
      "回合：130/200，奖励：137.00，Epislon：0.022\n",
      "回合：140/200，奖励：141.00，Epislon：0.017\n",
      "回合：150/200，奖励：200.00，Epislon：0.013\n",
      "找到新的最优策略，回合：151，模型步数：14000，测试奖励：200.00\n",
      "回合：160/200，奖励：200.00，Epislon：0.012\n",
      "找到新的最优策略，回合：161，模型步数：16000，测试奖励：200.00\n",
      "回合：170/200，奖励：200.00，Epislon：0.011\n",
      "找到新的最优策略，回合：171，模型步数：18000，测试奖励：200.00\n",
      "回合：180/200，奖励：200.00，Epislon：0.010\n",
      "找到新的最优策略，回合：181，模型步数：20000，测试奖励：200.00\n",
      "回合：190/200，奖励：200.00，Epislon：0.010\n",
      "找到新的最优策略，回合：191，模型步数：22000，测试奖励：200.00\n",
      "回合：200/200，奖励：200.00，Epislon：0.010\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 获取参数\n",
    "cfg = Config() \n",
    "env_mgr = EnvMgr(cfg) # 创建环境\n",
    "policy = Policy(cfg, env_mgr.state_dim, env_mgr.action_dim) # 创建策略\n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg, policy, env_mgr) # 训练\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_curve(cfg, range(len(res['rewards'])), res['rewards'], label = \"rewards\", title = f\"{cfg.mode}ing rewards on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "plot_curve(cfg, range(len(res['losses'])), res['losses'], label = \"losses\", title = f\"{cfg.mode}ing losses on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "plot_curve(cfg, range(len(res['eval_rewards'])), res['eval_rewards'], label = \"eval_rewards\", title = f\"online eval reward on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "joyrl-book",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
